home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / demos / video / vidtmesh.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  27.3 KB  |  1,270 lines
  1. /*
  2.  * Copyright (C) 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  * File:    vidtmesh.c 
  19.  *
  20.  *        Simple demonstration of video on tmesh grid. 
  21.  *        Uses much of 4Dgifts example, contcapt.c
  22.  *        for much of VL code
  23.  *        Also uses old rotimg.c code.
  24.  *
  25.  *        last modified 12/16/93 atang 
  26.  *                   2/28/94 atang add ripple, bumps, height, spin
  27.  *                   4/6/94  atang add even field capture
  28.  */
  29.  
  30. #include <sys/types.h>
  31. #include <sys/stat.h>
  32. #include <fcntl.h>
  33. #include <stdlib.h>
  34.  
  35. #include <stdio.h>
  36. #include <string.h>
  37. #include <malloc.h>
  38. #include <getopt.h>
  39. #include <sys/time.h>
  40. #include <gl/gl.h>
  41. #include <math.h>         /* for rotate image wavy calculations  */
  42. #include <gl/device.h>
  43. #include <gl/image.h>
  44.  
  45. #include <vl/vl.h>
  46. #include <vl/dev_ev1.h>
  47.  
  48. #define VL_PACKING_INVALID    -1
  49. #define Debug            if (debug) printf
  50. #define TIME_ARRAY_SIZE        400    /* MUST be divisible by 5! */
  51. #define TIME_GRANULARITY    1000
  52.  
  53. void         ProcessEvent(VLServer, VLEvent *, void *);
  54. void        ProcessGlEvent(int, void *);
  55. int        pause(void);
  56. void        exitcapture(void);
  57.  
  58. /*
  59.  *  Global variables
  60.  */
  61. char *cmdargs = "Bb:c:DfFehi:mn:p:r:tv:wz:";
  62. char *usage_m =
  63.     "usage: %s %s\n"
  64.     "where arguments may be:\n"
  65.     "    -B     source is blended video and gfx\n"
  66.     "    -b n    use n buffers\n"
  67.     "    -D    turn on debug mode (displays more information)\n"
  68.     "    -f    fast (low res gfx on move) mode (e.g. for XL gfx)\n"
  69.     "    -e    turn OFF even fields only mode\n"
  70.     "    -F    field mode\n"
  71.     "    -n n    device number n\n"
  72.     "    -o n     video output source to use (depends on hardware)\n"
  73.     "    -p n    set win position (1=upperLHS,0=lowerLHS(default))\n"
  74.     "    -h    this help message\n"
  75.     "    -v n     video input source to use (depends on hardware)\n"
  76. ;
  77.  
  78. char         *_progName;
  79. char        *deviceName;        
  80. int        devicenum = -1;
  81. int        ev1num = -1;
  82. int        blended = 0;
  83. int        buffers = 2;
  84. int        packing = VL_PACKING_INVALID;
  85. int        totalCount = 10000000;
  86. int        debug = 0;
  87. int        double_buffer = 1;
  88. int        fast = 0;
  89. int        fieldmode = 0;
  90. int        evenfields = 1;
  91. int        frameCount;
  92. int        frameInterval = -1;
  93. int        framenumber = 0;
  94. int        lasttime = 0;
  95. int        rate = 0;
  96. int        secs;
  97. int        time_array[TIME_ARRAY_SIZE];
  98. int        time_on = 0;
  99. int        xsize = 0;
  100. int        ysize = 0;
  101. int        zoom_num = 1, zoom_denom = 4; /* set zoom to 1/4 always */
  102. struct timeval    tv_save;
  103. VLPath        vlPath;
  104. VLServer    vlSvr;
  105. VLNode        drn;
  106. VLNode        src;
  107. VLNode        blend_node;
  108. VLBuffer    transferBuf;
  109. int        mywinposition = 0;
  110. int        selfspin = 0;
  111. int        spinspeed = 12;
  112. int        repeat = 1;
  113. int        ripple = 0;
  114. int        backcolor = 0;
  115. float        ripplespeed = 0.50;
  116. float        height = 0.8;
  117. float        mytranslate = 0.0;
  118. int        input_timing;
  119. int        vin = VL_ANY;
  120. int        vout = VL_ANY;
  121. int        vinflag = 0;
  122. int        voutflag = 0;
  123.  
  124.  
  125. /* ---------------- start rotate image variables here */
  126. int        lowres = 0;
  127.  
  128. #define X 0
  129. #define Y 1
  130. #define Z 2
  131.  
  132. unsigned short rb[2048];
  133. unsigned short gb[2048];
  134. unsigned short bb[2048];
  135.  
  136. unsigned long *colors; /* used by draw_grid (colors to put on tmesh) */
  137. unsigned long *rgbout; /* used by load_frame (convert rgb data to colors) */
  138.  
  139. float *grid;
  140. float wavymult = 1.0; /* used in wavy_grid to change function */
  141. int movewavy = 0; 
  142. float wavyinc =0.0;
  143. float pi_over_xsize;
  144. float pi_over_ysize;
  145.  
  146. float dist=0.0, d_dist=0.0;
  147. Angle azim=0, inc=0, twist=0;
  148. Angle d_azim=0, d_inc=0;
  149.  
  150. short mx, my, omx, omy, nmx, nmy;
  151. long sizex, sizey;
  152. long origx, origy;
  153.  
  154. short dev, val;
  155. int active=TRUE;
  156. long win;
  157. int menu;
  158.  
  159. int low_res, low_tmp;
  160. int function=0;
  161. #define REORIENT 1
  162. #define REDISTANCE 2
  163.  
  164. float ident_matrix[4][4] = {
  165.     {1.0, 0.0, 0.0, 0.0},
  166.     {0.0, 1.0, 0.0, 0.0},
  167.     {0.0, 0.0, 1.0, 0.0},
  168.     {0.0, 0.0, 0.0, 1.0},
  169. };
  170.  
  171. int y, rotxsize=160, rotysize=120;
  172.  
  173. IMAGE *image;
  174. char *title;
  175.  
  176. /* --------------- end rotate image variables here */
  177. /* --------------- start rotate image routines here */
  178.  
  179. reset_view(){
  180.  
  181. if (evenfields) dist = ysize*2;
  182.   else dist=ysize; 
  183. azim=0; inc=0; twist=0;
  184. d_dist=0.0;
  185. d_azim=0; d_inc=0;
  186.  
  187. return(0);
  188. }
  189.  
  190. clear_color_grid() {
  191.     int i, j;
  192.  
  193.     for (j=0; j<ysize; j++) {
  194.     for (i=0; i<xsize; i++) {
  195.         colors[j*xsize + i] = 0;
  196.     }
  197.     }
  198.     return(0);
  199. }
  200.  
  201.  
  202. setup_wavy_grid() {
  203.     int i, j;
  204.     float a, b, x, y, r;
  205.     r = xsize/4;
  206.  
  207.     for (j=0; j<ysize; j++) {
  208.     b = (float) j * 3.14159265359 / ysize;
  209.     if (!ripple) 
  210.         y = cos(b*3*repeat) * r;
  211.     else
  212.         y = r;
  213.     for (i=0; i<xsize; i++) {
  214.         a = (float) i * 3.14159265359 / xsize;
  215.         x = cos(a*2.0*repeat) * r;
  216.         grid[3 * (j*xsize + i) + 0] = i - xsize/2;
  217.         grid[3 * (j*xsize + i) + 1] = j - ysize/2;
  218.         grid[3 * (j*xsize + i) + 2] = height*((x + y)/3);
  219.     }
  220.     }
  221. }
  222.  
  223.  
  224. setup_flat_grid() {
  225.  
  226.     int ymult;
  227.     int i, j;
  228.  
  229.     for (j=0; j<ysize; j++) {
  230.     for (i=0; i<xsize; i++) {
  231.         grid[3 * (j*xsize + i) + 0] = i - xsize/2;
  232.         grid[3 * (j*xsize + i) + 1] = j - ysize/2;
  233.         grid[3 * (j*xsize + i) + 2] = 0;
  234.     }
  235.     }
  236. }
  237.  
  238. move_wavy_grid(){
  239.  
  240.     int i, j;
  241.     float a, b, x, y, r;
  242.     r = xsize/4;
  243.     
  244.     if (!ripple)
  245.     {
  246.     wavymult+= wavyinc;
  247.     if (wavymult >= 0.6)
  248.         if (wavymult >= 1) wavyinc = -0.05;
  249.         else 
  250.         wavyinc = -0.15;
  251.     if (wavymult <= -0.6)
  252.         if (wavymult <= -1) wavyinc = 0.05;
  253.         else
  254.         wavyinc = 0.15;
  255.     }else /* if ripple */
  256.     {
  257.     mytranslate = mytranslate + ripplespeed;
  258.     }
  259.     /* change the depth of the surface: */
  260.     for (j=0; j<ysize; j++) {
  261.     b = (float) j * pi_over_ysize;
  262.     if (!ripple) 
  263.         y = cos(b*3*repeat) * r;
  264.     else
  265.         y = r;
  266.     for (i=0; i<xsize; i++) {
  267.         a = (float) i * pi_over_xsize;
  268.         x = cos(mytranslate+a*2*repeat) * r;
  269.         grid[3 * (j*xsize + i) + 2] = height*((x + y)/2)*wavymult;
  270.     }
  271.     }
  272. }
  273.  
  274.  
  275. draw_grid() {
  276.  
  277.     register int i, j;
  278.     register float *gp1, *gp2;
  279.     register unsigned long *cp1, *cp2;
  280.  
  281.     for (j=0; (j<ysize-1) && !qtest(); j++) {    
  282.  
  283.     gp1 = &grid[3 * (j) * xsize]; 
  284.      gp2 = &grid[3 * (j+1) * xsize]; 
  285.      cp1 = &colors[j * xsize]; 
  286.      cp2 = &colors[(j+1) * xsize]; 
  287.  
  288.     bgntmesh();
  289.     for (i=0; i<xsize-1; i++) {
  290.         cpack(*cp1++);
  291.         v3f(gp1+=3);
  292.         cpack(*cp2++);
  293.         v3f(gp2+=3);
  294.     }
  295.     endtmesh();
  296.     }
  297. }
  298.  
  299. load_colors(unsigned short *row, unsigned long *dest, int xsize, int y, char c)
  300. {
  301.     int pos;
  302.  
  303.     pos = xsize * y;
  304.     dest = &dest[pos];
  305.     switch (c) {
  306.     case 'r':
  307.     case 'R':
  308.         while(xsize--) {
  309.         *dest = *dest++ + *row++;
  310.         }
  311.         break;
  312.     case 'g':
  313.     case 'G':
  314.         while(xsize--) {
  315.         *dest = *dest++ + ((*row++) << 8);
  316.         }
  317.         break;
  318.     case 'b':
  319.     case 'B':
  320.         while(xsize--) {
  321.         *dest = *dest++ + ((*row++) << 16);
  322.         }
  323.         break;
  324.     }
  325. }
  326.  
  327.  
  328. initialize() {
  329.     int vidx,vidy;
  330.  
  331.     keepaspect(xsize, rotysize);
  332.  
  333.     if ((input_timing == VL_TIMING_625_SQ_PIX) || 
  334.     (input_timing == VL_TIMING_625_CCIR601) ||
  335.     (input_timing == VL_TIMING_625_4FSC))
  336.     {/* PAL */
  337.     vidx = 768;
  338.     vidy = 576;
  339.     }else
  340.     {/* NTSC */
  341.     vidx = 640;
  342.     vidy = 486;
  343.     }
  344.     if (mywinposition == 1)
  345.     {
  346.       prefposition((long)0, (long)(vidx+10), (long)(1023-vidy), (long)1023); 
  347.     }else /* lower left */
  348.     {
  349.       prefposition ((long)0, (long)(vidx+10), (long)0, (long)(vidy)); 
  350.     }
  351.  
  352.     win=winopen("Video T-Mesh");
  353.  
  354.     doublebuffer();
  355.     RGBmode();
  356.     gconfig();
  357.     RGBcolor(0, 0, 0);
  358.     clear(); swapbuffers(); clear();
  359.  
  360.     qdevice(INPUTCHANGE);
  361.     qdevice(REDRAW);
  362.     qdevice(ESCKEY);
  363.     qdevice(SPACEKEY);
  364.     qdevice(UPARROWKEY);
  365.     qdevice(DOWNARROWKEY);
  366.     qdevice(LEFTARROWKEY);
  367.     qdevice(RIGHTARROWKEY);
  368.     qdevice(WINQUIT);
  369.     qdevice(WINSHUT);
  370.     qdevice(LEFTMOUSE);
  371.     qdevice(MIDDLEMOUSE);
  372.     qdevice(RIGHTMOUSE);
  373.  
  374.     getorigin(&origx, &origy);
  375.     getsize(&sizex, &sizey);
  376.     zbuffer(TRUE);
  377.     lsetdepth(0x00, 0x7fffff);
  378.     clear_color_grid();
  379.     setup_flat_grid();
  380.     menu = defpup("Flat|Wavy|Go Wavy|Ripple (speeds: 'r' key)\
  381.         |+ Height (up arrow)|- Height (down arrow)\
  382.         |Bumps (spacebar)|Background Colors ('c' key)\
  383.         |Spin On (speed: <- -> keys)\
  384.         |Low  Res Move|High Res Move\
  385.         |Reset All|Quit");
  386.     if (evenfields) dist = ysize*2;
  387.       else dist=ysize; 
  388.     return(0);
  389. }
  390.  
  391.  
  392. /* code for reading from disk (not currently called) */
  393. read_img()
  394. {
  395. }
  396.  
  397. draw_quick_grid(s)
  398. int s;
  399. {
  400.  
  401.     register int i, j, t;
  402.     register float *gp1, *gp2;
  403.     register unsigned long *cp1, *cp2;
  404.  
  405.     t = s * 3; 
  406.  
  407.     for (j=0; (j<ysize-2) && !qtest(); j+=2) { 
  408.     gp1 = &grid[3 * j * xsize];
  409.     gp2 = &grid[3 * (j+2) * xsize];
  410.     cp1 = &colors[j * xsize];
  411.     cp2 = &colors[(j+2) * xsize];
  412.     bgntmesh();
  413.     for (i=0; i<xsize-s; i+=s) {
  414.         cp1+=s;
  415.         cpack(*cp1);
  416.         v3f(gp1 += t);
  417.         cp2+=s;
  418.         cpack(*cp2);
  419.         v3f(gp2 += t);
  420.     }
  421.     endtmesh();
  422.     }
  423. }
  424.  
  425.  
  426.  
  427.  
  428. draw_scene() {
  429.  
  430.     switch (backcolor)
  431.     {
  432.     default:
  433.     case 1:
  434.         RGBcolor(0, 0, 255);
  435.         break;
  436.     case 2:
  437.         RGBcolor(0, 255, 0);
  438.         break;
  439.     case 3:
  440.         RGBcolor(255, 0, 0);
  441.         break;
  442.     case 4:
  443.         RGBcolor(255, 255, 255);
  444.         break;
  445.     case 0:
  446.         RGBcolor(0, 0, 0);
  447.         break;
  448.     }
  449.  
  450.     clear();
  451.     zclear();
  452.  
  453.     perspective(900, (float)sizex/(float)sizey, 1.0, 5000.0);
  454.  
  455.     if (selfspin)
  456.     {
  457.      azim = azim - spinspeed;  /* for auto rotate clockwise */
  458.     }
  459.  
  460. /*      inc = inc + 10;  */  /* for auto tilting */
  461. /*    polarview(dist + d_dist, azim + d_azim, inc + d_inc, twist); */
  462. /* XXX below: add 1800 to make up for reversed view... */
  463.  
  464.     if (evenfields) pushmatrix();
  465.     polarview(dist + d_dist, azim + d_azim, 1800 + inc + d_inc, twist); 
  466.     if (evenfields) scale(1.0, 2.0, 1.0); 
  467.  
  468. if (movewavy) move_wavy_grid();    
  469. if (lowres)
  470. {
  471.       if (function || movewavy) draw_quick_grid(low_tmp=low_res);   
  472.      else {
  473.      low_tmp = low_tmp/2;
  474.      if (low_tmp>1) draw_quick_grid(low_tmp);
  475.      else {draw_grid();
  476.          low_tmp=0;
  477.      }
  478.      }
  479. }else    /* end if lowres */
  480.     draw_grid();
  481.     if (evenfields) popmatrix();
  482.     if (!qtest()) swapbuffers();
  483. }
  484.  
  485.  
  486. /* --------------- end rotate image routines here */
  487.  
  488.  
  489. void
  490. initStatistics(void)
  491. {
  492.     if (!debug) return;
  493.     gettimeofday(&tv_save);
  494. }
  495.  
  496. void
  497. reportStatistics(void)
  498. {
  499.     double rate;
  500.     struct timeval tv;
  501.     int delta_t;
  502.  
  503.    /* Delta_t in microseconds */
  504.     delta_t = (tv.tv_sec*1000 + tv.tv_usec/1000) -
  505.           (tv_save.tv_sec*1000 + tv_save.tv_usec/1000);
  506.     
  507.     rate = frameCount*1000.0/delta_t;
  508.     
  509.     printf("got %5.2f frames/sec\n", rate);
  510.     tv_save.tv_sec = tv.tv_sec;
  511.     tv_save.tv_usec = tv.tv_usec;
  512.  
  513. }
  514.  
  515. char *
  516. packing_name (int packtype)
  517. {
  518.     switch (packtype) 
  519.     {
  520.     case VL_PACKING_RGB_8:    
  521.         return "RGB";
  522.     break;
  523.     
  524.         case VL_PACKING_RGBA_8:   
  525.         return "RGBA";
  526.     break;
  527.     
  528.     case VL_PACKING_RBG_323:   
  529.         return "Starter Video RGB8";
  530.     break;
  531.     
  532.     case VL_PACKING_RGB_332_P:    
  533.         return "RGB332";
  534.     break;
  535.     
  536.     case VL_PACKING_Y_8_P: 
  537.         return "8 Bit Greyscale";
  538.     break;
  539.     
  540.     default:        
  541.         return "???";
  542.     break;
  543.     }
  544. }
  545.  
  546. getcmdargs(int argc, char **argv)
  547. {
  548.     int c;
  549.     int len, xlen, ylen;
  550.     char numbuf[5];
  551.     char *xloc;
  552.    
  553.     while ((c = getopt(argc, argv, cmdargs)) != EOF) 
  554.     {
  555.     switch (c) 
  556.     {
  557.  
  558.         case 'b':
  559.         buffers = atoi(optarg);
  560.         break;
  561.  
  562.         case 'B':
  563.         blended = 1;
  564.         break;
  565.     
  566.         case 'c':
  567.         totalCount = atoi(optarg);
  568.         break;
  569.     
  570.         case 'D':
  571.         debug = 1;
  572.         break;
  573.  
  574.             case 'e':
  575.         evenfields = 0;
  576.         break;
  577.     
  578.         case 'f':
  579.         lowres = 1;
  580.         break;
  581.     
  582.         case 'F':
  583.         fieldmode = 1;
  584.         break;
  585.     
  586.         case 'g':
  587.         len = strlen(optarg);
  588.         xloc = strchr(optarg, 'x');
  589.         if (!xloc) 
  590.         {
  591.             printf("Error: invalid geometry format, using default size\n");
  592.             break;
  593.         }
  594.         xlen = len - strlen(xloc);
  595.         if (xlen < 1 || xlen > 4) 
  596.         {
  597.             printf("Error: invalid x size, using default size\n");
  598.             break;
  599.         }
  600.         strncpy(numbuf, optarg, xlen);
  601.         xsize = atoi(numbuf);
  602.     
  603.         ylen = len - xlen -1;
  604.         if (ylen < 1 || ylen > 4) 
  605.         {
  606.             printf("Error: invalid y size, using default size\n");
  607.             break;
  608.         }
  609.         strncpy(numbuf, &optarg[xlen + 1], ylen);
  610.         ysize = atoi(numbuf);
  611.         break;
  612.     
  613.         case 'i':
  614.         frameInterval = atoi(optarg);
  615.         printf("frameInterval = %d\n", frameInterval);
  616.         break;
  617.         
  618.         case 'm':
  619.         packing = VL_PACKING_Y_8_P;
  620.         break;
  621.     
  622.         case 'n':
  623.         devicenum = atoi(optarg);
  624.         printf("User specified device number: %d\n", devicenum);
  625.         break;
  626.  
  627.         case 'o':
  628.         vout = atoi(optarg);
  629.         voutflag = 1;
  630.         Debug ("video output = %d\n", vout);
  631.         break;
  632.     
  633.         case 'p':
  634.         mywinposition = atoi (optarg);
  635.         break;
  636.     
  637.         case 'r':
  638.         rate = atoi(optarg);
  639.         break;
  640.     
  641.         case 't':
  642.         time_on = 1;
  643.         break;
  644.     
  645.         case 'v':
  646.         vin = atoi(optarg);
  647.         vinflag = 1;
  648.         Debug ("video input = %d\n", vin);
  649.         break;
  650.     
  651.         case 'w':
  652.         packing = VL_PACKING_RGB_8;
  653.         break;
  654.         
  655.         case 'z': /* we're only supporting z 1/4 for now */
  656.         break;
  657.         
  658.         case 'h':
  659.         default:
  660.         fprintf(stderr, usage_m, _progName, cmdargs);
  661.         exit(0);
  662.         break;
  663.     }
  664.     }
  665. }
  666.  
  667. main(int argc, char **argv)
  668. {
  669.     VLDevList devlist;
  670.     char *deviceName;
  671.     char window_name[128];
  672.     char *xloc;
  673.     long win;
  674.     int c, i;
  675.     int len, xlen, ylen;
  676.     VLControlValue val;
  677.  
  678.     _progName = argv[0];
  679.  
  680.     getcmdargs(argc, argv);
  681.  
  682.     if (time_on)
  683.     for (c = 0; c < 1000; c++)
  684.         time_array[c] = 0;
  685.  
  686.     if (!(vlSvr = vlOpenVideo(""))) {
  687.     printf("couldn't open video\n");
  688.     exit(1);
  689.     }
  690.  
  691.     if (vlGetDeviceList(vlSvr, &devlist) < 0) {
  692.     printf("error getting device list: %s\n",vlStrError(vlErrno));
  693.     exit(1);
  694.     }
  695.    /* find ev1 */
  696.     for (i=0; i<devlist.numDevices; i++) 
  697.         if (strcmp(devlist.devices[i].name,"ev1") == 0)
  698.         ev1num = i;
  699.     if ( (ev1num == -1) /* no ev1 found ... OR ...*/
  700.     || ((devicenum != -1) && (devicenum != ev1num))) /* non ev1 specified*/
  701.     {
  702.       printf("This program requires 'ev1' hardware.\a\n");
  703.       if (ev1num != -1) 
  704.     printf("Use device number '%d', or use the default mode\n",ev1num);
  705.       exit(1);
  706.     }else
  707.     {
  708.       printf("Setting device number to %d\n", ev1num);
  709.       devicenum = ev1num; /* allow default to work */
  710.     }
  711.  
  712.     /* Set up a source node on the specified video source */
  713.     if (vinflag == 0)
  714.     src = vlGetNode(vlSvr, VL_SRC, VL_VIDEO, VL_ANY);
  715.     else
  716.     src = vlGetNode(vlSvr, VL_SRC, VL_VIDEO, vin);
  717.  
  718.     /* Set up a drain node in memory */
  719.     if (voutflag == 0)
  720.     drn = vlGetNode(vlSvr, VL_DRN, VL_MEM, VL_ANY);
  721.     else
  722.     drn = vlGetNode(vlSvr, VL_DRN, VL_MEM, vout);
  723.  
  724.     vlPath = vlCreatePath(vlSvr, devicenum, src, drn);
  725.     if (vlPath < 0) {
  726.     printf("can't create path: %s\n", vlStrError(vlErrno));
  727.     exit(1);
  728.     }
  729.  
  730.     /* Set up blend node if requested */
  731.     if (blended)
  732.     {
  733.       blend_node = vlGetNode(vlSvr, VL_INTERNAL, VL_BLENDER, VL_ANY);
  734.       if (vlAddNode(vlSvr, vlPath, blend_node) != 0)
  735.     {
  736.         vlDestroyPath(vlSvr, vlPath);
  737.         vlPath = -1;
  738.         vlPerror("Could not add blend node\n");
  739.     }
  740.     }
  741.   
  742.     if (vlSetupPaths(vlSvr, (VLPathList)&vlPath, 1, VL_SHARE, VL_SHARE) < 0){
  743.     printf ("could not setup a vid to mem path\n");
  744.     exit(1);
  745.     }
  746.  
  747.     /* get the current input timing */
  748.     vlGetControl(vlSvr, vlPath, src, VL_TIMING, &val);
  749.     input_timing = val.intVal;
  750.  
  751.     /* get the name of the device we're using */
  752.  
  753.     deviceName = devlist.devices[devicenum].name;
  754.     printf("Using device %d (%s)\n", devicenum, deviceName);
  755.  
  756.     /* specify what vlPath-related events we want to receive */
  757.     val.fractVal.numerator = zoom_num;
  758.     val.fractVal.denominator = zoom_denom;
  759.     vlSetControl(vlSvr, vlPath, drn, VL_ZOOM, &val);
  760.  
  761.  
  762.      /* Set the frame rate */
  763.     if (rate) 
  764.     {
  765.     val.intVal = rate;
  766.     vlSetControl(vlSvr, vlPath, src, VL_RATE, &val);
  767.     }
  768.     vlGetControl(vlSvr, vlPath, src, VL_RATE, &val);
  769.     Debug("frame rate = %d\n", val.intVal);
  770.  
  771.     /* 
  772.      * Specify what vlPath-related events we want to receive.
  773.      * In this example we only want transfer complete events.
  774.      */
  775.     vlSelectEvents(vlSvr, vlPath, VLTransferCompleteMask|VLTransferFailedMask);
  776.  
  777.     /* Set up for even frame capture */
  778.     if (evenfields) 
  779.     {
  780.     val.intVal = VL_CAPTURE_EVEN_FIELDS;
  781.     if (vlSetControl(vlSvr, vlPath, drn, VL_CAP_TYPE, &val) < 0)
  782.         vlPerror("Seting VL_PACKING");
  783.         
  784.     /* Make sure non-interleaved capture is supported by the harware */
  785.     if (vlGetControl(vlSvr, vlPath, drn, VL_CAP_TYPE, &val) < 0)
  786.         vlPerror("Geting VL_PACKING");
  787.     if (val.intVal != VL_CAPTURE_EVEN_FIELDS)
  788.         fprintf(stderr,"Capture type not set to EVEN_FIELDS: %d\n",
  789.         val.intVal);
  790.     Debug("Field (even) mode\n");
  791.     }
  792.  
  793.     /* Set up for non-interleaved frame capture */
  794.     if (fieldmode) 
  795.     {
  796.     val.intVal = VL_CAPTURE_NONINTERLEAVED;
  797.     if (vlSetControl(vlSvr, vlPath, drn, VL_CAP_TYPE, &val) < 0)
  798.         vlPerror("Seting VL_PACKING");
  799.         
  800.     /* Make sure non-interleaved capture is supported by the harware */
  801.     if (vlGetControl(vlSvr, vlPath, drn, VL_CAP_TYPE, &val) < 0)
  802.         vlPerror("Geting VL_PACKING");
  803.     if (val.intVal != VL_CAPTURE_NONINTERLEAVED)
  804.         fprintf(stderr,"Capture type not set to NONINTERLEAVED: %d\n",
  805.         val.intVal);
  806.     Debug("Field (non-interleaved) mode\n");
  807.     }
  808.  
  809.     /* Set the video geometry */
  810.     if (xsize) {
  811.     val.xyVal.x = xsize;
  812.     val.xyVal.y = ysize;
  813.     vlSetControl(vlSvr, vlPath, drn, VL_SIZE, &val);
  814.     }
  815.     vlGetControl(vlSvr, vlPath, drn, VL_SIZE, &val);
  816.     xsize = val.xyVal.x;
  817.     ysize = val.xyVal.y;
  818.     if (evenfields) 
  819.     ysize = ysize / 2;
  820.     if (ysize == 243){
  821.     ysize = ysize - 3;
  822.     }
  823.     if (ysize == 121){
  824.     ysize = ysize - 1;
  825.     }
  826.     val.xyVal.x = xsize;
  827.     val.xyVal.y = ysize;
  828.     vlSetControl(vlSvr, vlPath, drn, VL_SIZE, &val);
  829.     Debug("grabbing size %dx%d\n", xsize, ysize);
  830.     vlGetControl(vlSvr, vlPath, drn, VL_SIZE, &val);
  831.     printf("set SIZE to %d %d\n", val.xyVal.x, val.xyVal.y); 
  832.  
  833. /* -------------- start rotate image initialization here */
  834.  
  835.     pi_over_xsize = 3.14159265359 / xsize;
  836.     pi_over_ysize = 3.14159265359 / ysize;
  837.      colors = (unsigned long *)malloc(xsize*ysize*sizeof(unsigned long)); 
  838.     grid = (float *)malloc(xsize * ysize * 3 * sizeof(int));
  839.  
  840.     initialize();
  841.     fprintf(stderr, "\nUsing size %dx%d\n", xsize, ysize);
  842.     low_tmp = low_res = (xsize+ysize)/100 +1;
  843.  
  844. /* -------------- end rotate image initialization here */
  845.  
  846.  
  847.     foreground();
  848.     qdevice(RKEY);
  849.     qdevice(CKEY);
  850.     qdevice(QKEY);
  851.     qdevice(SKEY);
  852.  
  853.     pixmode(PM_TTOB, 1);
  854.  
  855.    /* Set the packing type for the video board */
  856.     if (packing != VL_PACKING_INVALID)
  857.     {
  858.     val.intVal = packing;
  859.     if (vlSetControl(vlSvr, vlPath, drn, VL_PACKING, &val) < 0)
  860.         vlPerror("Getting VL_PACKING");
  861.     }
  862.     
  863.     /* Set the graphics to the same packing as the video board */
  864.     vlGetControl(vlSvr, vlPath, drn, VL_PACKING, &val);
  865.     packing = val.intVal;
  866.     switch (val.intVal)
  867.     {
  868.     case VL_PACKING_Y_8_P:
  869.     /*
  870.      * XXX -gordo
  871.      *  this needs to restore the colormap
  872.      */
  873.         {
  874.         int i;
  875.             
  876.         /* Use colormap mode for greyscale */
  877.         cmode();            
  878.         for (i = 0; i < 256; i++)
  879.             mapcolor(i, i, i, i);
  880.         pixmode(PM_SIZE, 8);    /* Pixels are 8 bit Greyscale */
  881.         gconfig();      /* Reconfigure graphics */
  882.         }
  883.     break;
  884.     
  885.     case VL_PACKING_RGB_332_P:
  886.         pixmode(PM_SIZE, 9);    /* Pixels are 8 bit RGB */
  887.     break;
  888.     
  889.     case VL_PACKING_RBG_323:
  890.         pixmode(PM_SIZE, 8);
  891.     break;
  892.     
  893.     /* Unknown packing type, use RGB as the default */
  894.     default:        
  895.         packing = val.intVal = VL_PACKING_RGB_8;
  896.         if (vlSetControl(vlSvr, vlPath, drn, VL_PACKING, &val) < 0)
  897.         vlPerror("Setting RGB");
  898.         vlGetControl(vlSvr, vlPath, drn, VL_PACKING, &val);
  899.         Debug("packing type now is %s\n", packing_name(val.intVal));
  900.         if (val.intVal != packing)
  901.         {
  902.         fprintf(stderr, "%s: Error, could not set Packing to %s", _progName,
  903.             packing_name (packing));
  904.         exit(1);
  905.         }
  906.         /*
  907.          * There is no break here intentionally... the packing should
  908.          * now be VL_PACKING_RGB, and thus should fall through...
  909.          */
  910.     case VL_PACKING_RGB_8:
  911.     case VL_PACKING_RGBA_8:
  912.     break;
  913.     }
  914.  
  915.     vlGetControl(vlSvr, vlPath, drn, VL_SIZE, &val);
  916.     if (xsize != val.xyVal.x || ysize != val.xyVal.y) {
  917.     xsize = val.xyVal.x;
  918.     ysize = val.xyVal.y;
  919.     prefsize(xsize, ysize);
  920.     winconstraints();
  921.     reshapeviewport();
  922.     Debug("after VL_PACKING size is now %dx%d\n", xsize, ysize);
  923.     }
  924.  
  925.     /* Set up the ring buffer for data transfer */
  926.     transferBuf = vlCreateBuffer(vlSvr, vlPath, drn, buffers);
  927.     
  928.     /* Associate the ring buffer with the path */
  929.     vlRegisterBuffer(vlSvr, vlPath, drn, transferBuf);
  930.  
  931.     /* Set ProcessEvent() as the callback for a transfer complete event */
  932.     vlAddCallback(vlSvr, vlPath, VLTransferCompleteMask|VLTransferFailedMask, 
  933.             ProcessEvent, NULL);
  934.  
  935.    vlRegisterHandler(vlSvr, qgetfd(), (VLEventHandler)ProcessGlEvent,
  936.               (VLPendingFunc) qtest, (void *)win);
  937.  
  938.     if (vlBeginTransfer(vlSvr, vlPath, 0, NULL) < 0)
  939.     {
  940.     vlPerror("vlBeginTransfer");
  941.     exit(1);
  942.     }
  943.  
  944.     initStatistics();
  945.  
  946.     /* event loop */
  947.  
  948.  
  949.     vlMainLoop();
  950.  
  951. }
  952. void
  953. ProcessEvent(VLServer svr, VLEvent *ev, void *data)
  954. {
  955.     int count;
  956.     static int frameNum;
  957.     static ulong lasttime = -1;
  958.     static ulong lastsec;
  959.     int timeDiff;
  960.     DMediaInfo *dmInfo;
  961.     VLInfoPtr info;
  962.     char *dataPtr;
  963.  
  964.    /* Display the frame rate at a user specified interval */
  965.     if (frameInterval > 0 && frameCount > frameInterval)
  966.     {
  967.     reportStatistics();
  968.     frameCount = 0;
  969.     }
  970.  
  971.     switch (ev->reason)
  972.     {
  973.     case VLTransferComplete:
  974.     framenumber++;
  975.  
  976.     /* Get a pointer to the most recently captured frame */
  977.     info = vlGetLatestValid(svr, transferBuf);
  978.     if (!info)
  979.         break;
  980.  
  981.         /* Get the valid video data from that frame */
  982.     dataPtr = vlGetActiveRegion(svr, transferBuf, info);
  983.  
  984.     if (time_on)
  985.     {
  986.         dmInfo = vlGetDMediaInfo(svr, transferBuf, info);
  987.         if (lasttime != -1)
  988.         {
  989.             timeDiff = (dmInfo->time.tv_sec - lastsec) * TIME_GRANULARITY;
  990.             timeDiff += (int)(dmInfo->time.tv_usec - lasttime + 500) /
  991.                 (1000000 / TIME_GRANULARITY);
  992.             if (timeDiff >= TIME_ARRAY_SIZE)
  993.             timeDiff = TIME_ARRAY_SIZE-1;
  994.             time_array[timeDiff] += 1;
  995.         }
  996.         lasttime = dmInfo->time.tv_usec;
  997.         lastsec = dmInfo->time.tv_sec;
  998.     }
  999.  
  1000.     if (!fast)
  1001.     /* do some graphics here - this is part of the main loop */
  1002.     colors = (ulong *)dataPtr;
  1003.     draw_scene();
  1004.     /* start additional rotate image cases here */
  1005.     switch(function) {
  1006.         case REORIENT:
  1007.         mx = getvaluator(MOUSEX);
  1008.         my = getvaluator(MOUSEY);
  1009.         d_azim = (omx - mx) * 2 * getgdesc(GD_XPMAX) / sizex;
  1010.         /*XXX reversed to adjust for weird orient.,1800 added above */
  1011.          d_azim = - d_azim; 
  1012.         d_inc = (my - omy) * 2 * getgdesc(GD_YPMAX) / sizey;
  1013.         draw_scene();
  1014.         break;
  1015.         case REDISTANCE:
  1016.               mx = getvaluator(MOUSEX);
  1017.           my = getvaluator(MOUSEY);
  1018.           d_dist = ((omx - mx) + (my - omy)) * getgdesc(GD_XPMAX) /sizex;
  1019.           draw_scene();
  1020.           break;
  1021.     } /* end switch(function) */
  1022.     /* end additional rotate image cases here */
  1023.  
  1024.     vlPutFree(svr, transferBuf);
  1025.     frameCount++;
  1026.     if (framenumber >= totalCount)
  1027.         exitcapture();
  1028.     break;
  1029.     case VLTransferFailed:
  1030.     printf("VL transfer failed\n");    
  1031.     exitcapture(); 
  1032.     break;
  1033.     default:
  1034.     printf("Got Event %d\n", ev->reason);
  1035.     break;
  1036.     }
  1037. }
  1038.  
  1039.  
  1040. void
  1041. ProcessGlEvent(int fd, void *win)
  1042. {
  1043.     static short val;
  1044.     int loop;
  1045.     long device;
  1046.  
  1047.     while(qtest()){
  1048.        device = qread(&val);
  1049.        switch (device)
  1050.        {
  1051.  
  1052. /* start rotate image cases here */
  1053.         case INPUTCHANGE:
  1054.             active = val;
  1055.             if (val);
  1056.             break;
  1057.         case LEFTMOUSE:
  1058.             mx = getvaluator(MOUSEX);
  1059.             my = getvaluator(MOUSEY);
  1060.             if (val) {
  1061.             function=REDISTANCE;
  1062. /* setvaluators not doing what we need/expect right now esp w/move window*/
  1063. /*            setvaluator(MOUSEX, mx, origx+1, origx+sizex-1); */
  1064. /*             setvaluator(MOUSEY, my, origy+1, origx+sizey-1); */
  1065.             omx = mx; omy = my;
  1066.             } else {
  1067.             function=0;
  1068. /*             setvaluator(MOUSEX, mx, 0, XMAXSCREEN); */
  1069. /*             setvaluator(MOUSEY, my, 0, YMAXSCREEN); */
  1070.             dist += d_dist; d_dist = 0.0;
  1071.             draw_scene();
  1072.             }
  1073.             break;
  1074.         case MIDDLEMOUSE:
  1075.             mx = getvaluator(MOUSEX);
  1076.             my = getvaluator(MOUSEY);
  1077.             if (val) {
  1078.             function=REORIENT;
  1079. /*             setvaluator(MOUSEX, mx, origx+1, origx+sizex-1); */
  1080. /*             setvaluator(MOUSEY, my, origy+1, origx+sizey-1); */
  1081.             omx = mx; omy = my;
  1082.             } else {
  1083.                 function=0;
  1084. /*             setvaluator(MOUSEX, mx, 0, XMAXSCREEN); */
  1085. /*             setvaluator(MOUSEY, my, 0, YMAXSCREEN); */
  1086.             azim += d_azim; d_azim = 0;
  1087.             inc += d_inc; d_inc = 0;
  1088.             draw_scene();
  1089.             }
  1090.             break;
  1091.         case RIGHTMOUSE:
  1092.             if (val) {
  1093.             switch (dopup(menu)) {
  1094.                 case 1:
  1095.                 movewavy = 0;
  1096.                 setup_flat_grid();
  1097.                 break;
  1098.                 case 2:
  1099.                 movewavy = 0;
  1100.                 setup_wavy_grid();
  1101.                 break;
  1102.                 case 3:
  1103.                 movewavy = 1;
  1104.                 ripple = 0;
  1105.                 setup_wavy_grid();
  1106.                 break;
  1107.                 case 4:
  1108.                 movewavy = 1;
  1109.                 ripple = 1;
  1110.                 setup_wavy_grid();
  1111.                 break;                
  1112.                 case 5:
  1113.                 height = height + 0.1;
  1114.                 setup_wavy_grid();
  1115.                 break;                
  1116.                 case 6:
  1117.                 height = height - 0.1;
  1118.                 setup_wavy_grid();
  1119.                 break;                
  1120.                 case 7:
  1121.                 repeat = repeat + 1;
  1122.                 if (repeat > 15)
  1123.                   repeat = 1;
  1124.                 setup_wavy_grid();
  1125.                 break;                
  1126.                 case 8:
  1127.                 backcolor = backcolor + 1;
  1128.                 if (backcolor > 4)
  1129.                     backcolor = 0;
  1130.                 break;
  1131.                 case 9:
  1132.                 selfspin = 1;
  1133.                 lowres = 0;
  1134.                 break;                
  1135.                 case 10:
  1136.                 lowres = 1;
  1137.                 break;                
  1138.                 case 11:
  1139.                 lowres = 0;
  1140.                 break;                
  1141.                 case 12:
  1142.                 reset_view();
  1143.                 backcolor = 0;
  1144.                 ripple = 0;
  1145.                 ripplespeed = 0.50;
  1146.                 repeat = 1;
  1147.                 height = 0.8;
  1148.                 selfspin = 0;
  1149.                 spinspeed = 12;
  1150.                 mytranslate = 0.0;
  1151.                 wavymult = 1.0;
  1152.                 movewavy = 0;
  1153.                 setup_flat_grid();
  1154.                 break;
  1155.                 case 13:
  1156.                 gexit(); /* add for graphics */
  1157.                 exitcapture();
  1158.                 break;
  1159.             }
  1160.             draw_scene();
  1161.             }
  1162.             break;
  1163.         case REDRAW:
  1164.             reshapeviewport();
  1165.             getorigin(&origx, &origy);
  1166.             getsize(&sizex, &sizey);
  1167.             draw_scene();
  1168.             break;
  1169. /* end rotate image cases here */
  1170.  
  1171.     /* Toggle double buffer mode */
  1172.     case RKEY :
  1173.         if (val)
  1174.         {
  1175.             ripplespeed = ripplespeed + 0.1;
  1176.             if (ripplespeed > 1.2)
  1177.             ripplespeed = 0.1;
  1178.         }
  1179.         break;
  1180.     case CKEY :
  1181.         if (val)
  1182.         {
  1183.             backcolor = backcolor + 1;
  1184.             if (backcolor > 4)
  1185.             backcolor = 0;
  1186.         }
  1187.         break;
  1188.     case SPACEKEY:
  1189.         if (val)
  1190.         {
  1191.             repeat = repeat + 1;
  1192.             if (repeat > 15)
  1193.             repeat = 1;
  1194.             setup_wavy_grid();
  1195.         }
  1196.         break;
  1197.     case UPARROWKEY:
  1198.         height = height + 0.1;
  1199.         setup_wavy_grid();
  1200.         break;
  1201.     case DOWNARROWKEY:
  1202.         height = height - 0.1;
  1203.         setup_wavy_grid();
  1204.         break;
  1205.     case LEFTARROWKEY:
  1206.         if (val)
  1207.         {
  1208.         spinspeed = spinspeed - 3;
  1209.         break;
  1210.         }
  1211.     case RIGHTARROWKEY:
  1212.         if (val)
  1213.         {
  1214.         spinspeed = spinspeed + 3;
  1215.         break;
  1216.         }
  1217.     /* Quit capture */
  1218.     case QKEY :
  1219.         if (val != 1)
  1220.         break;
  1221.  
  1222.     case ESCKEY:
  1223.     case WINSHUT:
  1224.     case WINQUIT:
  1225.         gexit(); /* add for graphics */
  1226.         exitcapture();
  1227.         exit(0);
  1228.         break;
  1229.        } /* end switch */
  1230.     } /* end while qtest */
  1231. /* additional processing (e.g. REORIENT, REDISTANCE) are */
  1232. /* processed within the video processing loop           */
  1233. /* see ProcessEvent                     */
  1234.  
  1235. }
  1236.  
  1237. void
  1238. exitcapture()
  1239. {
  1240.     int loop, j;
  1241.  
  1242.     /* End the data transfer */
  1243.     vlEndTransfer(vlSvr, vlPath);
  1244.  
  1245.     /* Disassociate the ring buffer from the path */
  1246.     vlDeregisterBuffer(vlSvr, vlPath, drn, transferBuf);
  1247.  
  1248.     /* Destroy the path, free the memory it used */
  1249.     vlDestroyPath(vlSvr,vlPath);
  1250.     
  1251.     /* Destroy the ring buffer, free the memory it used */
  1252.     vlDestroyBuffer(vlSvr, transferBuf);
  1253.  
  1254.     /* Disconnect from the daemon */
  1255.     vlCloseVideo(vlSvr);
  1256.  
  1257.     /* Print the time stamps from the captured frames */
  1258.     if (time_on)
  1259.         for (loop = 0; loop < TIME_ARRAY_SIZE; ) {
  1260.         printf("%3d: ", loop);
  1261.         for (j = 0; j < 5; j++)
  1262.             printf("\t%d", time_array[loop++]);
  1263.         printf("\n");
  1264.         }
  1265.  
  1266.     exit(0);
  1267. }
  1268.  
  1269. /* === */
  1270.